(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
        (function (factory) {
            if (typeof exports === 'object') {
                // Node/CommonJS
                module.exports = factory();
            } else if (typeof define === 'function' && define.amd) {
                // AMD
                define(factory);
            } else {
                // Browser globals (with support for web workers)
                var glob;

                try {
                    glob = window;
                } catch (e) {
                    glob = self;
                }

                glob.SparkMD5 = factory();
            }
        }(function (undefined) {

            'use strict';

            /*
             * Fastest md5 implementation around (JKM md5).
             * Credits: Joseph Myers
             *
             * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
             * @see http://jsperf.com/md5-shootout/7
             */

            /* this function is much faster,
              so if possible we use it. Some IEs
              are the only ones I know of that
              need the idiotic second function,
              generated by an if clause.  */
            var add32 = function (a, b) {
                    return (a + b) & 0xFFFFFFFF;
                },
                hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];


            function cmn(q, a, b, x, s, t) {
                a = add32(add32(a, q), add32(x, t));
                return add32((a << s) | (a >>> (32 - s)), b);
            }

            function ff(a, b, c, d, x, s, t) {
                return cmn((b & c) | ((~b) & d), a, b, x, s, t);
            }

            function gg(a, b, c, d, x, s, t) {
                return cmn((b & d) | (c & (~d)), a, b, x, s, t);
            }

            function hh(a, b, c, d, x, s, t) {
                return cmn(b ^ c ^ d, a, b, x, s, t);
            }

            function ii(a, b, c, d, x, s, t) {
                return cmn(c ^ (b | (~d)), a, b, x, s, t);
            }

            function md5cycle(x, k) {
                var a = x[0],
                    b = x[1],
                    c = x[2],
                    d = x[3];

                a = ff(a, b, c, d, k[0], 7, -680876936);
                d = ff(d, a, b, c, k[1], 12, -389564586);
                c = ff(c, d, a, b, k[2], 17, 606105819);
                b = ff(b, c, d, a, k[3], 22, -1044525330);
                a = ff(a, b, c, d, k[4], 7, -176418897);
                d = ff(d, a, b, c, k[5], 12, 1200080426);
                c = ff(c, d, a, b, k[6], 17, -1473231341);
                b = ff(b, c, d, a, k[7], 22, -45705983);
                a = ff(a, b, c, d, k[8], 7, 1770035416);
                d = ff(d, a, b, c, k[9], 12, -1958414417);
                c = ff(c, d, a, b, k[10], 17, -42063);
                b = ff(b, c, d, a, k[11], 22, -1990404162);
                a = ff(a, b, c, d, k[12], 7, 1804603682);
                d = ff(d, a, b, c, k[13], 12, -40341101);
                c = ff(c, d, a, b, k[14], 17, -1502002290);
                b = ff(b, c, d, a, k[15], 22, 1236535329);

                a = gg(a, b, c, d, k[1], 5, -165796510);
                d = gg(d, a, b, c, k[6], 9, -1069501632);
                c = gg(c, d, a, b, k[11], 14, 643717713);
                b = gg(b, c, d, a, k[0], 20, -373897302);
                a = gg(a, b, c, d, k[5], 5, -701558691);
                d = gg(d, a, b, c, k[10], 9, 38016083);
                c = gg(c, d, a, b, k[15], 14, -660478335);
                b = gg(b, c, d, a, k[4], 20, -405537848);
                a = gg(a, b, c, d, k[9], 5, 568446438);
                d = gg(d, a, b, c, k[14], 9, -1019803690);
                c = gg(c, d, a, b, k[3], 14, -187363961);
                b = gg(b, c, d, a, k[8], 20, 1163531501);
                a = gg(a, b, c, d, k[13], 5, -1444681467);
                d = gg(d, a, b, c, k[2], 9, -51403784);
                c = gg(c, d, a, b, k[7], 14, 1735328473);
                b = gg(b, c, d, a, k[12], 20, -1926607734);

                a = hh(a, b, c, d, k[5], 4, -378558);
                d = hh(d, a, b, c, k[8], 11, -2022574463);
                c = hh(c, d, a, b, k[11], 16, 1839030562);
                b = hh(b, c, d, a, k[14], 23, -35309556);
                a = hh(a, b, c, d, k[1], 4, -1530992060);
                d = hh(d, a, b, c, k[4], 11, 1272893353);
                c = hh(c, d, a, b, k[7], 16, -155497632);
                b = hh(b, c, d, a, k[10], 23, -1094730640);
                a = hh(a, b, c, d, k[13], 4, 681279174);
                d = hh(d, a, b, c, k[0], 11, -358537222);
                c = hh(c, d, a, b, k[3], 16, -722521979);
                b = hh(b, c, d, a, k[6], 23, 76029189);
                a = hh(a, b, c, d, k[9], 4, -640364487);
                d = hh(d, a, b, c, k[12], 11, -421815835);
                c = hh(c, d, a, b, k[15], 16, 530742520);
                b = hh(b, c, d, a, k[2], 23, -995338651);

                a = ii(a, b, c, d, k[0], 6, -198630844);
                d = ii(d, a, b, c, k[7], 10, 1126891415);
                c = ii(c, d, a, b, k[14], 15, -1416354905);
                b = ii(b, c, d, a, k[5], 21, -57434055);
                a = ii(a, b, c, d, k[12], 6, 1700485571);
                d = ii(d, a, b, c, k[3], 10, -1894986606);
                c = ii(c, d, a, b, k[10], 15, -1051523);
                b = ii(b, c, d, a, k[1], 21, -2054922799);
                a = ii(a, b, c, d, k[8], 6, 1873313359);
                d = ii(d, a, b, c, k[15], 10, -30611744);
                c = ii(c, d, a, b, k[6], 15, -1560198380);
                b = ii(b, c, d, a, k[13], 21, 1309151649);
                a = ii(a, b, c, d, k[4], 6, -145523070);
                d = ii(d, a, b, c, k[11], 10, -1120210379);
                c = ii(c, d, a, b, k[2], 15, 718787259);
                b = ii(b, c, d, a, k[9], 21, -343485551);

                x[0] = add32(a, x[0]);
                x[1] = add32(b, x[1]);
                x[2] = add32(c, x[2]);
                x[3] = add32(d, x[3]);
            }

            function md5blk(s) {
                var md5blks = [],
                    i; /* Andy King said do it this way. */

                for (i = 0; i < 64; i += 4) {
                    md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
                }
                return md5blks;
            }

            function md5blk_array(a) {
                var md5blks = [],
                    i; /* Andy King said do it this way. */

                for (i = 0; i < 64; i += 4) {
                    md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
                }
                return md5blks;
            }

            function md51(s) {
                var n = s.length,
                    state = [1732584193, -271733879, -1732584194, 271733878],
                    i,
                    length,
                    tail,
                    tmp,
                    lo,
                    hi;

                for (i = 64; i <= n; i += 64) {
                    md5cycle(state, md5blk(s.substring(i - 64, i)));
                }
                s = s.substring(i - 64);
                length = s.length;
                tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
                for (i = 0; i < length; i += 1) {
                    tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
                }
                tail[i >> 2] |= 0x80 << ((i % 4) << 3);
                if (i > 55) {
                    md5cycle(state, tail);
                    for (i = 0; i < 16; i += 1) {
                        tail[i] = 0;
                    }
                }

                // Beware that the final length might not fit in 32 bits so we take care of that
                tmp = n * 8;
                tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
                lo = parseInt(tmp[2], 16);
                hi = parseInt(tmp[1], 16) || 0;

                tail[14] = lo;
                tail[15] = hi;

                md5cycle(state, tail);
                return state;
            }

            function md51_array(a) {
                var n = a.length,
                    state = [1732584193, -271733879, -1732584194, 271733878],
                    i,
                    length,
                    tail,
                    tmp,
                    lo,
                    hi;

                for (i = 64; i <= n; i += 64) {
                    md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
                }

                // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
                // containing the last element of the parent array if the sub array specified starts
                // beyond the length of the parent array - weird.
                // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
                a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);

                length = a.length;
                tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
                for (i = 0; i < length; i += 1) {
                    tail[i >> 2] |= a[i] << ((i % 4) << 3);
                }

                tail[i >> 2] |= 0x80 << ((i % 4) << 3);
                if (i > 55) {
                    md5cycle(state, tail);
                    for (i = 0; i < 16; i += 1) {
                        tail[i] = 0;
                    }
                }

                // Beware that the final length might not fit in 32 bits so we take care of that
                tmp = n * 8;
                tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
                lo = parseInt(tmp[2], 16);
                hi = parseInt(tmp[1], 16) || 0;

                tail[14] = lo;
                tail[15] = hi;

                md5cycle(state, tail);

                return state;
            }

            function rhex(n) {
                var s = '',
                    j;
                for (j = 0; j < 4; j += 1) {
                    s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
                }
                return s;
            }

            function hex(x) {
                var i;
                for (i = 0; i < x.length; i += 1) {
                    x[i] = rhex(x[i]);
                }
                return x.join('');
            }

            // In some cases the fast add32 function cannot be used..
            if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') {
                add32 = function (x, y) {
                    var lsw = (x & 0xFFFF) + (y & 0xFFFF),
                        msw = (x >> 16) + (y >> 16) + (lsw >> 16);
                    return (msw << 16) | (lsw & 0xFFFF);
                };
            }

            // ---------------------------------------------------

            /**
             * ArrayBuffer slice polyfill.
             *
             * @see https://github.com/ttaubert/node-arraybuffer-slice
             */

            if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {
                (function () {
                    function clamp(val, length) {
                        val = (val | 0) || 0;

                        if (val < 0) {
                            return Math.max(val + length, 0);
                        }

                        return Math.min(val, length);
                    }

                    ArrayBuffer.prototype.slice = function (from, to) {
                        var length = this.byteLength,
                            begin = clamp(from, length),
                            end = length,
                            num,
                            target,
                            targetArray,
                            sourceArray;

                        if (to !== undefined) {
                            end = clamp(to, length);
                        }

                        if (begin > end) {
                            return new ArrayBuffer(0);
                        }

                        num = end - begin;
                        target = new ArrayBuffer(num);
                        targetArray = new Uint8Array(target);

                        sourceArray = new Uint8Array(this, begin, num);
                        targetArray.set(sourceArray);

                        return target;
                    };
                })();
            }

            // ---------------------------------------------------

            /**
             * Helpers.
             */

            function toUtf8(str) {
                if (/[\u0080-\uFFFF]/.test(str)) {
                    str = unescape(encodeURIComponent(str));
                }

                return str;
            }

            function utf8Str2ArrayBuffer(str, returnUInt8Array) {
                var length = str.length,
                    buff = new ArrayBuffer(length),
                    arr = new Uint8Array(buff),
                    i;

                for (i = 0; i < length; i += 1) {
                    arr[i] = str.charCodeAt(i);
                }

                return returnUInt8Array ? arr : buff;
            }

            function arrayBuffer2Utf8Str(buff) {
                return String.fromCharCode.apply(null, new Uint8Array(buff));
            }

            function concatenateArrayBuffers(first, second, returnUInt8Array) {
                var result = new Uint8Array(first.byteLength + second.byteLength);

                result.set(new Uint8Array(first));
                result.set(new Uint8Array(second), first.byteLength);

                return returnUInt8Array ? result : result.buffer;
            }

            function hexToBinaryString(hex) {
                var bytes = [],
                    length = hex.length,
                    x;

                for (x = 0; x < length - 1; x += 2) {
                    bytes.push(parseInt(hex.substr(x, 2), 16));
                }

                return String.fromCharCode.apply(String, bytes);
            }

            // ---------------------------------------------------

            /**
             * SparkMD5 OOP implementation.
             *
             * Use this class to perform an incremental md5, otherwise use the
             * static methods instead.
             */

            function SparkMD5() {
                // call reset to init the instance
                this.reset();
            }

            /**
             * Appends a string.
             * A conversion will be applied if an utf8 string is detected.
             *
             * @param {String} str The string to be appended
             *
             * @return {SparkMD5} The instance itself
             */
            SparkMD5.prototype.append = function (str) {
                // Converts the string to utf8 bytes if necessary
                // Then append as binary
                this.appendBinary(toUtf8(str));

                return this;
            };

            /**
             * Appends a binary string.
             *
             * @param {String} contents The binary string to be appended
             *
             * @return {SparkMD5} The instance itself
             */
            SparkMD5.prototype.appendBinary = function (contents) {
                this._buff += contents;
                this._length += contents.length;

                var length = this._buff.length,
                    i;

                for (i = 64; i <= length; i += 64) {
                    md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
                }

                this._buff = this._buff.substring(i - 64);

                return this;
            };

            /**
             * Finishes the incremental computation, reseting the internal state and
             * returning the result.
             *
             * @param {Boolean} raw True to get the raw string, false to get the hex string
             *
             * @return {String} The result
             */
            SparkMD5.prototype.end = function (raw) {
                var buff = this._buff,
                    length = buff.length,
                    i,
                    tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    ret;

                for (i = 0; i < length; i += 1) {
                    tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
                }

                this._finish(tail, length);
                ret = hex(this._hash);

                if (raw) {
                    ret = hexToBinaryString(ret);
                }

                this.reset();

                return ret;
            };

            /**
             * Resets the internal state of the computation.
             *
             * @return {SparkMD5} The instance itself
             */
            SparkMD5.prototype.reset = function () {
                this._buff = '';
                this._length = 0;
                this._hash = [1732584193, -271733879, -1732584194, 271733878];

                return this;
            };

            /**
             * Gets the internal state of the computation.
             *
             * @return {Object} The state
             */
            SparkMD5.prototype.getState = function () {
                return {
                    buff: this._buff,
                    length: this._length,
                    hash: this._hash
                };
            };

            /**
             * Gets the internal state of the computation.
             *
             * @param {Object} state The state
             *
             * @return {SparkMD5} The instance itself
             */
            SparkMD5.prototype.setState = function (state) {
                this._buff = state.buff;
                this._length = state.length;
                this._hash = state.hash;

                return this;
            };

            /**
             * Releases memory used by the incremental buffer and other additional
             * resources. If you plan to use the instance again, use reset instead.
             */
            SparkMD5.prototype.destroy = function () {
                delete this._hash;
                delete this._buff;
                delete this._length;
            };

            /**
             * Finish the final calculation based on the tail.
             *
             * @param {Array}  tail   The tail (will be modified)
             * @param {Number} length The length of the remaining buffer
             */
            SparkMD5.prototype._finish = function (tail, length) {
                var i = length,
                    tmp,
                    lo,
                    hi;

                tail[i >> 2] |= 0x80 << ((i % 4) << 3);
                if (i > 55) {
                    md5cycle(this._hash, tail);
                    for (i = 0; i < 16; i += 1) {
                        tail[i] = 0;
                    }
                }

                // Do the final computation based on the tail and length
                // Beware that the final length may not fit in 32 bits so we take care of that
                tmp = this._length * 8;
                tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
                lo = parseInt(tmp[2], 16);
                hi = parseInt(tmp[1], 16) || 0;

                tail[14] = lo;
                tail[15] = hi;
                md5cycle(this._hash, tail);
            };

            /**
             * Performs the md5 hash on a string.
             * A conversion will be applied if utf8 string is detected.
             *
             * @param {String}  str The string
             * @param {Boolean} raw True to get the raw string, false to get the hex string
             *
             * @return {String} The result
             */
            SparkMD5.hash = function (str, raw) {
                // Converts the string to utf8 bytes if necessary
                // Then compute it using the binary function
                return SparkMD5.hashBinary(toUtf8(str), raw);
            };

            /**
             * Performs the md5 hash on a binary string.
             *
             * @param {String}  content The binary string
             * @param {Boolean} raw     True to get the raw string, false to get the hex string
             *
             * @return {String} The result
             */
            SparkMD5.hashBinary = function (content, raw) {
                var hash = md51(content),
                    ret = hex(hash);

                return raw ? hexToBinaryString(ret) : ret;
            };

            // ---------------------------------------------------

            /**
             * SparkMD5 OOP implementation for array buffers.
             *
             * Use this class to perform an incremental md5 ONLY for array buffers.
             */
            SparkMD5.ArrayBuffer = function () {
                // call reset to init the instance
                this.reset();
            };

            /**
             * Appends an array buffer.
             *
             * @param {ArrayBuffer} arr The array to be appended
             *
             * @return {SparkMD5.ArrayBuffer} The instance itself
             */
            SparkMD5.ArrayBuffer.prototype.append = function (arr) {
                var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),
                    length = buff.length,
                    i;

                this._length += arr.byteLength;

                for (i = 64; i <= length; i += 64) {
                    md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
                }

                this._buff = (i - 64) < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);

                return this;
            };

            /**
             * Finishes the incremental computation, reseting the internal state and
             * returning the result.
             *
             * @param {Boolean} raw True to get the raw string, false to get the hex string
             *
             * @return {String} The result
             */
            SparkMD5.ArrayBuffer.prototype.end = function (raw) {
                var buff = this._buff,
                    length = buff.length,
                    tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    i,
                    ret;

                for (i = 0; i < length; i += 1) {
                    tail[i >> 2] |= buff[i] << ((i % 4) << 3);
                }

                this._finish(tail, length);
                ret = hex(this._hash);

                if (raw) {
                    ret = hexToBinaryString(ret);
                }

                this.reset();

                return ret;
            };

            /**
             * Resets the internal state of the computation.
             *
             * @return {SparkMD5.ArrayBuffer} The instance itself
             */
            SparkMD5.ArrayBuffer.prototype.reset = function () {
                this._buff = new Uint8Array(0);
                this._length = 0;
                this._hash = [1732584193, -271733879, -1732584194, 271733878];

                return this;
            };

            /**
             * Gets the internal state of the computation.
             *
             * @return {Object} The state
             */
            SparkMD5.ArrayBuffer.prototype.getState = function () {
                var state = SparkMD5.prototype.getState.call(this);

                // Convert buffer to a string
                state.buff = arrayBuffer2Utf8Str(state.buff);

                return state;
            };

            /**
             * Gets the internal state of the computation.
             *
             * @param {Object} state The state
             *
             * @return {SparkMD5.ArrayBuffer} The instance itself
             */
            SparkMD5.ArrayBuffer.prototype.setState = function (state) {
                // Convert string to buffer
                state.buff = utf8Str2ArrayBuffer(state.buff, true);

                return SparkMD5.prototype.setState.call(this, state);
            };

            SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;

            SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;

            /**
             * Performs the md5 hash on an array buffer.
             *
             * @param {ArrayBuffer} arr The array buffer
             * @param {Boolean}     raw True to get the raw string, false to get the hex one
             *
             * @return {String} The result
             */
            SparkMD5.ArrayBuffer.hash = function (arr, raw) {
                var hash = md51_array(new Uint8Array(arr)),
                    ret = hex(hash);

                return raw ? hexToBinaryString(ret) : ret;
            };

            return SparkMD5;
        }));

    },{}],2:[function(require,module,exports){
        'use strict';

        function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; }

        var browserMD5File = require('./browser-md5-file');

        (function (factory) {
            if (typeof define === 'function' && define.amd) {
                define([], factory);
            } else if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') {
                window.browserMD5File = factory();
            }
        })(function () {

            return browserMD5File;
        });

    },{"./browser-md5-file":3}],3:[function(require,module,exports){
        'use strict';

        var SparkMD5 = require('spark-md5');

        module.exports = function (file, callback) {
            var blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
            var chunkSize = 2097152;
            var chunks = Math.ceil(file.size / chunkSize);
            var currentChunk = 0;
            var spark = new SparkMD5.ArrayBuffer();
            var reader = new FileReader();

            loadNext();

            reader.onloadend = function (e) {
                spark.append(e.target.result); // Append array buffer
                currentChunk++;

                if (currentChunk < chunks) {
                    loadNext();
                } else {
                    callback(null, spark.end());
                }
            };

            reader.onerror = function () {
                callback('oops, something went wrong.');
            };

            /////////////////////////
            function loadNext() {
                var start = currentChunk * chunkSize;
                var end = start + chunkSize >= file.size ? file.size : start + chunkSize;

                reader.readAsArrayBuffer(blobSlice.call(file, start, end));
            }
        };

    },{"spark-md5":1}]},{},[2]);

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
        'use strict';

        var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

        var event = require('./util-event');

        (function (factory) {
            if (typeof define === 'function' && define.amd) {
                define([], factory);
            } else if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') {
                window.event = factory();
            }
        })(function () {

            return event;
        });

    },{"./util-event":2}],2:[function(require,module,exports){
        'use strict';

        var event = {
            bind: function bind(element, name, listener) {
                element.addEventListener(name, listener, false);
            },

            unbind: function unbind(element, name, listener) {
                element.removeEventListener(name, listener, false);
            },

            once: function once(element, name, listener) {
                var that = this;
                var once = function once(e) {
                    that.unbind(element, name, once);
                    listener(e);
                };

                that.bind(element, name, once);
            }
        };

        module.exports = event;

    },{}]},{},[1]);
